Desenvolvimento de algoritmos para solução de problemas

Em matemática e ciência da computação, um algoritmo é uma sequência finita de ações executáveis que visam obter uma solução para um determinado tipo de problema.

 – pt.wikipedia.org/wiki/Algoritmo

Algoritmo


O conceito de algoritmo é frequentemente ilustrado pelo exemplo de uma receita culinária, embora muitos algoritmos sejam mais complexos. Eles podem repetir passos (fazer iterações) ou necessitar de decisões (tais como comparações ou lógica) até que a tarefa seja completada.


Um algoritmo não representa, necessariamente, um programa de computador, e sim os passos necessários para realizar uma tarefa.

Etapas para construção de um programa


1. Definição do problema

2. Projetar a solução (algorítmo)

3. Codificar a solução (programar em uma linguagem)

4. Testar o programa

Etapas para construção de um programa


  1. Qual é o próximo número da sequência:

\[1, 1, 2, 3, 5, 8, 13,\dots\]

\[ \begin{align} F(n)=F(n-1)+F(n-2), \\ \text{com}\; n \geq 1\;\text{e}\; F(1) = F(2) = 1 \end{align} \]

def fibonacci_de(n):
    if n in {1, 2}:
        return 1
    return fibonacci_de(n - 1) + fibonacci_de(n - 2)
[fibonacci_de(n) for n in range(1, 9)]
[1, 1, 2, 3, 5, 8, 13, 21]

Introdução ao Python

Instalação


  1. Abra a Microsoft Store no seu computador.
  2. Na barra de pesquisa, digite Python.
  3. Selecione a versão desejada do Python (geralmente, a mais recente).
  4. Clique em Obter e aguarde a instalação ser concluída.
  5. Após a instalação, o Python estará disponível no seu sistema, e você pode verificar digitando python --version no terminal.
  1. Abra a Microsoft Store.
  2. Na barra de pesquisa, digite Visual Studio Code.
  3. Selecione o Visual Studio Code da Microsoft.
  4. Clique em Obter e aguarde a instalação ser concluída.
  5. Após a instalação, o VSCode estará disponível no seu sistema e pode ser aberto através do menu Iniciar.

Depois de instalar ambos, você pode usar o VSCode para escrever e rodar código Python diretamente.

Google Colab


Acesso em https://research.google.com/colaboratory/

pip um gerenciador de pacotes


# Instalar 1 ou + pacotes
pip install pandas folium

# Instalar um conjunto de pacotes a partir do arquivo requirements.txt
pip install -r requirements.txt

# Listar todos os pacotes instalados
pip freeze

Módulos


Para utlizar as funções de outros pacotes é necessário carregar os módulos com import:

import re

txt = "unasp fica no estado de sp"
x = re.findall("sp", txt); x
['sp', 'sp']


import re as regex

txt = "unasp fica no estado de sp"
x = regex.findall("sp", txt); x
['sp', 'sp']


from re import findall

txt = "unasp fica no estado de sp"
x = findall("sp", txt); x
['sp', 'sp']

Aritmética


Cálculos simples \(\frac{((5 + 3) \times 7)}{5}\)

(5 + 3) * 7/5
11.2


Potência \(10^2\)

10**2
100

Raiz quadrada \(\sqrt{100}\)

from math import sqrt
sqrt(100)
10.0


Derivada \(f'(x) = \text{cos}(x)\)

from sympy import *
x = symbols('x')
diff(cos(x), x)

\(\displaystyle - \sin{\left(x \right)}\)

Variáveis e entrada de dados

Em programação, variáveis são utilizadas para armazenar valores. Então x = 1, a variável x armazena o valor 1

Nomes de variáveis


Nomes aceitos

  • a1
  • velocidade
  • velocidade90
  • salário_médio
  • _b

Nomes não aceitos

  • salário médio (utilizando espaço)
  • 1a (começando com números)

Variáveis numéricas


Números inteiros

a = 1_000
b = 2
c = -5


Números de ponto flutuante ou decimais

d = 1.0
e = 5.478
g = 3000.67

Verificando o tipo com a função type

type(a)
int
type(d)
float

Variáveis do tipo lógico

resultado = True
aprovado = False


Operadores relacionais

# Variáveis
a = 2
b = 5
c = 5
# Operadores relacionais
b > a
a < b
c <= b
c == b
a != b
1
Variáveis a, b e c
2
b maior do que a
3
a menor do que b
4
c é menor ou igual a b
5
c é igual a b
6
a é diferente de b
True
True
True
True
True

Verificando o tipo

type(resultado)
bool

Operadores lógicos


not True
not False
True and True
True and False
False and True
False and False
True or True
True or False
False or True
False or False
False
True
True
False
False
False
True
True
True
False

Expressões lógicas

True or False and not True
True

Variáveis string

Variáveis do tipo string armazenam cadeias de caracteres como nomes e textos em geral.


s = "texto"
type(s)
str

O tamanho de uma string pode ser obtido utilizando-se a função len:

len(s)
5

Operações com strings


Concatenação

s = "ABC"
s + "D"
'ABCD'
"#" + 20 * "-" + "#"
'#--------------------#'


Composição

"%s tem %d anos e R$%.2f" % ("João", 40, 50.453)
'João tem 40 anos e R$50.45'
"{} tem {} anos e R${:.2f}".format("João", 40, 50.453)
'João tem 40 anos e R$50.45'
nome, idade, dinheiro = "João", 40, 50.453
f"{nome} tem {idade} anos e R${dinheiro:.2f}"
'João tem 40 anos e R$50.45'

Entrada de dados


A função input é utilizada para solicitar dados do usuário. Ela recebe um parâmetro, que é a mensagem a ser exibida, e retorna o valor digitado pelo usuário.

x = input("Digite um número: ")
print(x)


Produzindo a seguinte saída na tela:

Digite um número: 5
5

Exercícios


Faça um programa que calcule o aumento de um salário. Ele deve solicitar o valor do salário e a porcentagem do aumento. Exiba o valor do salário, percentual de aumento e do novo salário.

# Inputs
salario = float(input("Digite seu salário: "))
percentual = float(input("Digite o percentual de aumento: "))

# Cálculo
novo_salario = salario * (1 + percentual/100)

# Resultado
print(f"O meu salário é R${salario:.2f}, o percentual de aumento foi {percentual:.1f}% e o novo salário será de R${novo_salario:.2f}")
1
Definir os inputs, lembrar que se está lidando com números utilizar float
2
Cálculo do novo salário
3
Resultado compondo com as variáveis e cálculos anteriores

Condições

As condições servem para selecionar quando uma parte do programa deve ser ativada e quando deve ser simplesmente ignorada

Condições


if

if <condição>:
  bloco verdadeiro

else

if <condição>:
  bloco verdadeiro
else:
  bloco alternativo

elif

Inserindo mais condições

if <condição>:
  bloco verdadeiro
elif <condição>:
  bloco verdadeiro para esta condição

Exercício


Faça um programa que calcule o aumento de um salário. Ele deve solicitar o valor do salário e o nível do cargo. Cargo junior terá um aumento de 10%, pleno de 20% e senior 30%. Mostre uma saída com o salário, o cargo e o novo salário.

salario = float(input("Digite seu salário: "))
cargo = input("Digite o nível do cargo: ")
if cargo == "junior":
  novo_salario = salario * 1.1
elif cargo == "pleno":
  novo_salario = salario * 1.2
elif cargo == "senior":
  novo_salario = salario * 1.3 
else:
  print("Cargo não identificado!")

print(f"O meu salário é R${salario:.2f}, mas com o meu cargo {cargo}, o novo salário será de R${novo_salario:.2f}")
1
Se o cargo é junior o salário é multiplicado por 1 + 0,1 (10%)

Exercício


O exercício anterior considerando que se o profissional no cargo senior tiver filho o salário terá um acréscimo de R$ 500

salario = float(input("Digite seu salário: "))
cargo = input("Digite o nível do cargo: ")
if cargo == "junior":
  novo_salario = salario * 1.1
elif cargo == "pleno":
  novo_salario = salario * 1.2
elif cargo == "senior":
  novo_salario = salario * 1.3
  filhos = input("Você tem filhos? ")
  if filhos == "sim":
    novo_salario += 500
else:
  print("Cargo não identificado!")

print(f"O meu salário é R${salario:.2f}, mas com o meu cargo {cargo}, o novo salário será de R${novo_salario:.2f}")
1
if aninhado

Operação ternária

Seria uma forma mais simplificada de utilizar condições.


x = 54
"Maior do que 50" if x > 50 else "Menor ou igual a 50"
'Maior do que 50'

Match case

Seria uma outra forma de aplicar condições no código. Nós reescreveremos o problema do aumento de salário.


salario = float(input("Digite seu salário: "))
cargo = input("Digite o nível do cargo: ")
match cargo:
  case "junior":
    novo_salario = salario * 1.1
  case "pleno":
    novo_salario = salario * 1.2
  case "senior":
    novo_salario = salario * 1.3 
  case _:
    print("Cargo não identificado!")
    novo_salario = None

if novo_salario is not None:
  print(f"O meu salário é R${salario:.2f}, mas com o meu cargo {cargo}, o novo salário será de R${novo_salario:.2f}")

Repetições

São utilizadas para executar a mesma parte de um programa várias vezes

Repetições


while

while <condição>:
  bloco


Imprimir números de 1 a 5

x = 1
while x <= 5:
  print(x)
  x += 1
1
Inicializa com o número 1
2
Combina a estrutura condicional com a estrutura de repetição
3
Repete estas linhas enquanto a condição for verdadeira

Enquanto não sair, continuar repetindo a pergunta


while

exit = False
while not exit:

    exit = input("Você quer sair? ")
    if exit == "Sim":
        exit = True
        print("Bye!")
    else:
        exit = False

Exercício


Construa um programa que solicite para qual número deve ser calculada a tabuada de multiplicação

n = int(input("Tabuada de: "))
x = 0
while x <= 10:
    print(f"{n} {chr(215)} {x} = {n * x}")
    x = x + 1
1
A função chr mostra um caractere unicode

Repetições


Acumuladores com while

Programa para calcular a soma de 10 números inseridos

n = 1
soma = 0
while n <= 10:
  x = int(input(f"Digite o {n} número: "))
  soma += x
  n += 1
print(f"Soma: {soma}")
1
Variável acumuladora

Repetições


Acumuladores com while

Programa para calcular a média de 10 números inseridos

n = 1
soma = 0
while n <= 10:
  x = int(input(f"Digite o {n} número: "))
  soma += x
  n += 1
print(f"Média: {soma/10:.1f}")

Operadores de atribuição especial


Equivalências:

  • x += 1 \(\Longleftrightarrow\) x = x + 1
  • y -= 1 \(\Longleftrightarrow\) y = y - 1
  • c *= 1 \(\Longleftrightarrow\) c = c * 2
  • d /= 1 \(\Longleftrightarrow\) d = d / 1
  • e **= 1 \(\Longleftrightarrow\) e = e ** 1
  • f //= 1 \(\Longleftrightarrow\) f = f // 1

Repetições


Interrompendo a repetição while

s = 0
while True:
  v = int(input("Digite um número a somar ou 0 para sair: "))
  if v == 0:
    break
  s += v
print(s)
1
Instrução utilizada para interromper a execução de while

Para continuar uma repetição existe a instrução continue

Repetições


Barra de progresso while

import os 
import time

print("\033[?25l", end="")
x = 1    
tamanho, _ = os.get_terminal_size()
tamanho = tamanho - 5
while x <= tamanho - 5:
    bar = chr(9608) * x + f" {x * 100 / tamanho:.0f}"
    print(bar)
    time.sleep(.1)
    os.system('cls')
    x = x + 1
1
Apagar cursor
2
Esta função pega o tamanho da janela do terminal
3
O programa dorme por 0.1 seg
4
Limpar a tela (este comando não funciona no jupyter ou outro notebook)


███████████████████████████████████████████████████ 76%

Símbolos Unicode


Como apresentando no último exemplo, no python, é possível incluir símbolos utilizando a função chr.

[(i, chr(i)) for i in [9608, 9816, 128187, 128665, 129315, 128099, 8721, 128375]]
[(9608, '█'),
 (9816, '♘'),
 (128187, '💻'),
 (128665, '🚙'),
 (129315, '🤣'),
 (128099, '👣'),
 (8721, '∑'),
 (128375, '🕷')]

Uma lista poderá ser encontrada aqui https://symbl.cc/ com os símbolos e códigos. O código que deverá ser utilizado é a parte numérica do HTML (&#128375;)

Estrutura de dados

Listas


A lista é representada por [], seguem alguns exemplos:

[1, 2, 3, 4]
["a", "b", "c"]
["a", 5, True]
[[1, "a"], [True, 2.6]]
1
Lista de inteiros
2
Lista de strings
3
Lista com tipos mesclados
4
Listas aninhadas
[1, 2, 3, 4]
['a', 'b', 'c']
['a', 5, True]
[[1, 'a'], [True, 2.6]]


Podemos extrair elementos da lista utilizando []:

minha_lista = [4, 5, 8, 1, 9, 5]

minha_lista[0]
minha_lista[2]
minha_lista[-1]
minha_lista[3:5]
1
Extraindo o primeiro elemento da lista utilizando o índice 0
2
Extraindo o terceiro elemento da lista utilizando o índice 2
3
Extraindo o último elemento da lista utilizando o índice -1
4
Extraindo os elementos de índice 3 a 4 3:5
4
8
5
[1, 9]

Listas


Percorrendo uma lista com while e dar print de cada valor

notas = [9, 5, 4, 3, 9, 2]

i = 0
while i < 6:
  print(notas[i])
  i = i + 1
9
5
4
3
9
2


Eu poderia substituir 6 por len(notas)

notas = [9, 5, 4, 3, 9, 2]

i = 0
while i < len(notas):
  print(notas[i])
  i = i + 1
9
5
4
3
9
2

Listas


Utilizando for

Temos a opção de utilizar for para percorrer uma lista e dar print de cada valor

notas = [9, 5, 4, 3, 9, 2]

for i in notas:
  print(i)
9
5
4
3
9
2

Cópia de lista e substituição por um determinado valor


L = ["a", "b", "c", "d", "e"]
K = L
L[3] = "r"
print(K)
1
Cópia a lista L e salvo na variável K
2
Substituição do elemento “d” pelo elemento “r”
3
Como K é cópia de L, qualquer alteração em L produz uma alteração em K
['a', 'b', 'c', 'r', 'e']

Uma outra forma de cópia seria utilizando o comando [:]

L = ["a", "b", "c", "d", "e"]
K = L[:]
L[3] = "r"
print(K)
1
Esta forma de cópia inpede que K receba alterações se L for alterado.
2
Substituição do elemento “d” pelo elemento “r”
['a', 'b', 'c', 'd', 'e']

Métodos

Métodos são semanticamente o mesmo que funções, mas há duas diferenças sintáticas: Os métodos são definidos dentro de uma definição de classe. Dois métodos para inserir novos dados em uma lista são:

  • append insere um elemento em uma lista
  • extend insere vários elementos em uma lista
L = ["a", "b", "c", "d", "e"]
L.append("f")
print(L)
['a', 'b', 'c', 'd', 'e', 'f']
L = ["a", "b", "c", "d", "e"]
L.extend(["f", "g", "h"])
print(L)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

Se utilizar append para inserir multiplos itens ele será inserido como um único item

L = ["a", "b", "c", "d", "e"]
L.append(["f", "g", "h"])
print(L)
['a', 'b', 'c', 'd', 'e', ['f', 'g', 'h']]

Adicionar elementos em uma lista


Criar uma programa que adicione repetidamente números em uma lista, mas que ao digitar o número 0 o programa é interrompido

L = []
while True:
  n = int(input("Digite um número (0 para sair): "))
  if n == 0:
    break
  L.append(n)
print(f"Esta é a minha lista: {L}")

Quantas letras tem em uma lista


Criar uma programa que verifique quantas letras “a” aparecem na lista

soma = 0
for i in ["a", "b", "a", "f"]:
  if i == "a":
    soma += 1
print(soma)
2

Qual é o máximo desta lista


Crie um programa que calcule o valor máximo de uma lista

L = [1, 7, 4, 5, 2]

maximo = L[0]
for i in L:
  if i > maximo:
    maximo = i
print(f"O número máximo é o: {maximo}")
O número máximo é o: 7

Digite um texto e qual letra gostaria de contar


Criar uma programa que solicite uma frase e a letra que gostaria que fosse contada

from unidecode import unidecode

texto = input("Digite uma frase: ")
letra = input("Qual letra gostaria de contar: ")

soma = 0
for i in texto:
  if unidecode(i.lower()) == letra:
    soma += 1
print(f"A quantidade de '{letra}' nesta frase é de: {soma}")


  • Para remover acentos foi utilizado o unidecode
  • Para instalar pip3 install unidecode

Dicionário


O dicionário é definido por {} e estruturado sempre com uma chave 'a' e um valor 1, sendo separados por “:

x = {'a': 1, 'b': 2}


Para obter um valor podemos usar [] com uma chave x['a'] para poder retornar o valor associado a chave

x["a"]
1

O dicionário tem dois métodos utilizados para retornar uma lista de chaves e valores

x.keys()
x.values()
dict_keys(['a', 'b'])
dict_values([1, 2])

Dicionário


Para adicionar uma nova chave e valor

x["c"] = 3
x
{'a': 1, 'b': 2, 'c': 3}


É possível adicionar outras estruturas de dados como valores no dicionário

x["d"] = ["f", "g", "h"]
x
{'a': 1, 'b': 2, 'c': 3, 'd': ['f', 'g', 'h']}

Dicionário


Caixa de supermercado

tabela = {"Alface": 5.00,
          "Batata": 4.55,
          "Tomate": 9.80,
          "Feijão": 7.30}
valor_total = 0
while True:
    produto = input("Qual o produto? ").capitalize()
   
    if produto == "Sair":
        print("Bye!")
        break
       
    quantidade = int(input("Quantidade: "))
    valor_produto = tabela[produto] * quantidade
    valor_total = valor_total + valor_produto
print(f"Valor total das compras foi de: R${valor_total:.2f}")
1
Inicializando o valor total
2
Solicitando o nome do produto
3
Se escrever “Sair” o programa é interrompido
4
Solicitando a quantidade
5
Computando o valor do produto baseado na quantidade
6
Valor total das compras

Dicionário


Contagem de letras

d = {}
for letra in "abracadabra":
  d[letra] = d.get(letra, 0) + 1
print(d)
{'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

Dicionário


Contagem de letras

import pprint

d = {}
for letra in "abracadabra":
  d[letra] = d.get(letra, 0) + 1

for letra in d.keys():
    d[letra] = d[letra] * chr(9608)

pp = pprint.PrettyPrinter(width=1)
pp.pprint(d)
{'a': '█████',
 'b': '██',
 'c': '█',
 'd': '█',
 'r': '██'}

Tupla


As tuplas são similares às listas, mas com a diferença de serem imutáveis, ou seja, não é possível substituir um elemento.

x = (1, 2, 3, 4)
x[2]
1
Na tupla os valores são definidos por parenteses
2
Da mesma forma que a lista, os valores poderão ser extraídos pelo seu índice
3


Contudo podemos concatenar tuplas

(1, 2, 3) + (4, 5)
(1, 2, 3, 4, 5)


Um tupla com somente um elemento deve ser incluída a ,

(4,)
(4,)

Conjunto


Os conjuntos trazem a mesma ideia dos conjuntos da matemática. Um detalhe importante é se elementos repetidos forem incluidos eles são removidos automaticamente.

x = {1, 2, 3, 4, 4, 2, 1}
x
{1, 2, 3, 4}


Para adicionar um elemento

x.add(5)
x
{1, 2, 3, 4, 5}

Conjunto


União entre conjuntos

A = {1, 2, 3}
B = {4, 5, 6}
A | B
{1, 2, 3, 4, 5, 6}


Interseção entre conjuntos

A = {1, 2, 3}
B = {3, 4, 5}
A & B
{3}


Diferença entre conjuntos

A = {1, 2, 3}
B = {2, 3, 4, 5}
B - A
{4, 5}

Funções

Funções


Uma função em python é iniciada com def, deve se incluir um nome_função, incluir argumento e uma declaração return para retornar o resultado

def nome_função(argumento):
  return argumento + 5


Para utilizar a função

nome_função(10)
15

Funções


Função para verificar se o número é par

def ehpar(num):
  return num % 2 == 0
ehpar(9)
ehpar(4)
False
True


Função para dizer se é par ou ímpar

def par_ou_impar(num):
  if ehpar(num):
    return "par"
  else:
    return "ímpar"
par_ou_impar(9)
par_ou_impar(4)
'ímpar'
'par'

Funções


Calcular a soma de elementos de uma lista

def somar_lista(lista):
  soma = 0
  for e in lista:
    soma = soma + e
  return soma

somar_lista([1, 2, 3, 4])
10

Calcular a média de elementos de uma lista

def media_lista(lista):
  soma = 0
  for e in lista:
    soma = soma + e
  return soma/len(lista)

media_lista([1, 2, 3, 4])
2.5

Funções


Variáveis locais e globais

a = 'global'
def f():
  a = 'local'
  print(a)

f()
print(a)
local
global


a = 'global'
def f():
  global a
  a = 'local'
  print(a)

f()
print(a)
1
Declarando a variável a como global, assim uma atribuição dentro da função afeta atribuições fora da função
local
local

Funções


Criar uma função que retorna o aumento de salário. Os argumentos necessários para calcular este aumento de salário são o salário atual e o cargo que o profissional ocupa. Contudo se o cargo é junior o aumento será de de 10%, se for pleno o aumento será de 20% e se for senior o aumento será de 30%.

def aumento_salario(salario, cargo):
  if cargo == "junior":
    return salario * 1.1
  elif cargo == "pleno":
    return salario * 1.2
  elif cargo == "senior":
    return salario * 1.3
  else:
    return "Cargo não identificado"

Aplicação da função

aumento_salario(1100, "pleno")
1320.0

Funções


Jogo da Velha

def tic_tac_toe():
    
    data = {}

    def move(data, pos):
        pos = data.get(pos, pos)
        if pos == 1:
            return chr(215)
        elif pos == 0:
            return chr(9711)
        else:
            return pos

    def show_board():
        print(f' {move(data, "1")} | {move(data, "2")} | {move(data, "3")} ')
        print("-" * 11)
        print(f' {move(data, "4")} | {move(data, "5")} | {move(data, "6")} ')
        print("-" * 11)
        print(f' {move(data, "7")} | {move(data, "8")} | {move(data, "9")} ')
        print("\n")

    def winner_checker():
        win_pos = ["123", "456", "789", "147", "258", "369", "159", "357"]
        win_checkers = [[data.get(i) for i in j] for j in win_pos]
        check = True in [(set(i) == {1}) | (set(i) == {0}) for i in win_checkers]
        return check

    while True:
        
        show_board()
        
        player1 = input(f"Select a position (player {chr(215)}): ")
        print("\n")
        
        data[player1] = 1

        if winner_checker():
          print(f"Player {chr(215)} Won!\n")
          show_board()
          break
        
        show_board()
        
        player2 = input(f"Select a position (player {chr(9711)}): ")
        print("\n")
        
        data[player2] = 0

        if winner_checker():
          print(f"Player {chr(9711)} Won!\n")
          show_board()
          break

Exceções

Exceções


Mesmo que um comando ou expressão estejam sintaticamente corretos, talvez ocorra um erro na hora de sua execução. Erros detectados durante a execução são chamados exceções

print(y)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[418], line 1
----> 1 print(y)

NameError: name 'y' is not defined


Podemos tratar as exceções utilizando o bloco try/except

try:
  print(y)
except:
  print("Variável não foi definida")
Variável não foi definida

Exceções


É possível também concatenar um texto padrão com o texto de erro

try:
  print(y)
except Exception as err:
  print(f"ERRO: {err}")
ERRO: name 'y' is not defined

É possível também utilizar mais de uma exceção para direcionar diferentes tipos de erros

y = [1, 2, 3]
while True:
  try:
    i = int(input("Digite um número: "))
    print(y[i])
    break
  except IndexError as err:
    print("ERRO: ", err)
  except ValueError as err:
    print("ERRO: ", err)

Exercício


Escreva um programa que pergunte a distância que um passageiro deseja percorrer em km. Calcule o preço da passagem, cobrando R$ 0.50 por km para viagens de até 200 km, R$ 0.45 para viagens entre 200 e 400 km e para viagens mais longas será cobrado R$ 0.35 por km. O programa só deve ser encerrado quando o usuário escrever sair.

while True:
    dist = input("Digite a distância: ")
    try:
        if dist.capitalize() == "Sair":
            print("Bye!")
            break
        else:
            dist = float(dist)

        if dist <= 200:
            preco = dist * 0.5
        elif (dist > 200) & (dist <= 400):
            preco = dist * 0.45
        elif dist > 400:
            preco = dist * 0.35
        print(f"O preço ficou em R${preco:.2f}")
        
    except:
        print("Valor inválido")

Git/Github

Git é um sistema de controle de versão que ajuda a gerenciar e acompanhar mudanças no seu código, enquanto o GitHub é uma plataforma online onde você pode hospedar seus repositórios Git, colaborar com outros desenvolvedores e compartilhar seus projetos de forma fácil e segura. Ambos são ferramentas essenciais para quem trabalha com desenvolvimento de software!

Git

  • Iniciar um repositório: Criar um novo repositório Git localmente.
  • Clonar repositório: Fazer uma cópia de um repositório remoto para o seu computador.
  • Adicionar mudanças ao staging: Preparar as alterações para serem commitadas, colocando-as na área de staging.
  • Commit das mudanças: Salvar as alterações no histórico do repositório
  • Enviar para o repositório remoto: Subir as mudanças locais para o repositório remoto na internet.
  • Atualizar local: Trazer as últimas mudanças do repositório remoto para o seu repositório local.

Mensagens semânticas de commit1


O commit semântico é uma prática de escrever mensagens de commit de forma clara e padronizada, usando um formato que indica o tipo de mudança feita (como correção, adição ou remoção) e uma descrição breve.

Exemplo

feat: add hat wobble
^--^  ^------------^
|     |
|     +-> Resumo no tempo presente.
|
+-------> Tipo: chore (tarefas), docs (documentação), feat (recurso), fix (correção), refactor (refatoração), style (estilo), ou test (teste).

Mensagens semânticas de commit1


  • feat: (new feature for the user, not a new feature for build script)
  • fix: (bug fix for the user, not a fix to a build script)
  • docs: (changes to the documentation)
  • style: (formatting, missing semi colons, etc; no production code change)
  • refactor: (refactoring production code, eg. renaming a variable)
  • test: (adding missing tests, refactoring tests; no production code change)
  • chore: (updating grunt tasks etc; no production code change)